home *** CD-ROM | disk | FTP | other *** search
/ Aminet 49 / Aminet 49 (2002)(GTI - Schatztruhe)[!][Jun 2002].iso / Aminet / dev / gg / codeblue-amiga.lha / codeblue.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-03-04  |  26.9 KB  |  1,083 lines
  1. /*
  2.  * $Header: /usr/src/Projects/codeblue/codeblue.c,v 1.1 2001/08/02 20:40:01 root Exp root $
  3.  *
  4.  ******************************************************************************************
  5.  *                      -[ G O D  B L E S S  A M E R I C A ]-                             *
  6.  ******************************************************************************************
  7.  *
  8.  *            CodeBlue v5 by Michael (mystic@tenebrous.com)
  9.  *  This software is freely distributable under the terms of the GNU/GPL.
  10.  *                    Please see file 'COPYING'
  11.  *
  12.  *              Copyright(c) 2001 mystic@tenebrous.com
  13.  *             In cooporation with worm.jungnickel.com.
  14.  *
  15.  *    CodeBlue is a simple program which scans an Apache access log file,
  16.  *  searching for hosts who requested documents notoriously associated with
  17.  *  malicious worms such as CodeRed and Nimda, and attempts to email these hosts
  18.  *  with a warning about their infection and where to find more information.
  19.  *
  20.  *    This is an attempt to increase the awareness of malicious worms
  21.  *  and eventually elliminate their existence.
  22.  *
  23.  *   This program is free software; you can redistribute it and/or modify
  24.  *   it under the terms of the GNU General Public License as published by
  25.  *   the Free Software Foundation; either version 2 of the License, or
  26.  *   (at your option) any later version.
  27.  *
  28.  *   This program is distributed in the hope that it will be useful,
  29.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  30.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31.  *   GNU General Public License for more details.
  32.  *
  33.  *   You should have received a copy of the GNU General Public License
  34.  *   along with this program; if not, write to the Free Software
  35.  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  36.  *
  37.  *   Author contact: Michael <mystic@tenebrous.com>
  38.  *
  39.  * $Log: codeblue.c,v $
  40.  * Revision 1.1  2001/08/02 20:40:01  root
  41.  * Initial revision
  42.  *
  43.  ******************************************************************************************/
  44. #include <stdio.h>
  45. #include <stdlib.h>
  46. #include <string.h>
  47. #include <errno.h>
  48. #include <signal.h>
  49. #include <unistd.h>
  50. #include <fcntl.h>
  51. #include <time.h>
  52. #include <ctype.h>
  53. #include <sys/time.h>
  54. #include <sys/types.h>
  55. #include <sys/socket.h>
  56. #include <netinet/in.h>
  57. #include <arpa/inet.h>
  58. #include <netdb.h>
  59.  
  60.  
  61.  
  62. /*
  63.  * The path to your system whois binary
  64.  */
  65. #define WHOIS_PATH "/usr/bin/whois"
  66.  
  67.  
  68. /* 
  69.  * This variable holds the 'triggers' to search for when scanning
  70.  * the Apachge log file..
  71.  */
  72. #define MAX_TRIGGERS 3        /* specifies number of triggers we have in trigger (below) */
  73.  
  74. static const char trigger[MAX_TRIGGERS][56] = {
  75.     "GET /default.ida?NNNNNN",    /* Code Red I  */
  76.     "GET /default.ida?XXXXXX",    /* Code Red II */
  77.     "GET /scripts/root.exe"    /* Nimda       */
  78. };
  79.  
  80.  
  81.  
  82.  
  83. /*
  84.  * Macros - Please do not change
  85.  */
  86. #define SMTP_SUBJECT "You may be infected [CB]"
  87. #define SMTP_USER    "postmaster"
  88. #define SMTP_PORT    25
  89. #define SMTP_TIMEOUT 5
  90. #define SEND_FL 0x0        /* send flags */
  91. #define RECV_FL 0x0        /* recv flags */
  92.  
  93.  
  94. /*
  95.  * Flags to be used in command line parsing..
  96.  */
  97. unsigned short flags = 0;    /* global flag reference */
  98. #define FL_SENDQUERY (1<<1) 
  99. #define FL_WHOIS     (1<<2) 
  100. #define FL_BEQUIET   (1<<3)
  101.  
  102. /*
  103.  *
  104.  * Global Variables Section
  105.  *
  106.  */
  107.  
  108. /*
  109.  * This is the content of our warning email:
  110.  * Please do not change!
  111.  */
  112. static const char *message = "This message was automatically generated by CodeBlue. Please do not reply.\n\n\n" "\tAfter scanning our web-server log files, we have noticed that your host,\n" "%s, may very well be infected with a malicious worm.\n" "\n" "\tThe following is a line from our Apache log file that validates the infection of\n" "%s:\n" "\n%s\n\n" "This worm appears to be: %s\n\n" "\tIt is HIGHLY recommended that you remove this worm at once! To find information\n" "on how to remove this worm and prevent future attacks, please visit\n" "www.dshield.org and www.incidents.org.\n\n" "Thank you\n" "Sincerely,\n" "The Code-Blue team\n" "\r\n.\r\n";    /* this is needed to signify end of input */
  113.  
  114. char infected_host[512];    /* Stores address of infected host */
  115. char logline[512];        /* Stores GET line from access log */
  116. char reply[512];        /* stores reply email address */
  117. static unsigned int filepos = 0;    /* stores file position */
  118. FILE *log;            /* log file stream */
  119. FILE *fp;            /* access_log file stream */
  120. int hostswarned = 0, hostsnwarned = 0;    /* Keeps tracks of how many hosts warned/not warned */
  121. int lastresponse;        /* stores last SMTP response */
  122. char hostlist[2048 * 512];    /* stores hosts as we warn them */
  123. char wormstyle[32];        /* stores name of worm */
  124. int mainsock;            /* our main socket descriptor */
  125. char whoispath[512] = "/usr/bin/whois";    /* Path to whois program */
  126.  /****************************************************************/
  127.  
  128. /* 
  129.  * More macros
  130.  */
  131. #define TRUE    1
  132. #define FALSE   0
  133. #define SUCCESS 0
  134. #define FAILURE 1
  135.  
  136.  
  137.  
  138. /*********************************************************************
  139.  * FUNCTION PROTOTYPES GO HERE
  140.  */
  141. void banner(void);
  142. void usage(char *);
  143. void DieWithHelp(char *);
  144. void DieWithRequire(char *);
  145. void signal_init(void);
  146. void signal_handler(int);
  147. int Close(int);
  148. int resolv(const char *, struct sockaddr_in *);
  149. char *chop(char *);
  150. void invalid_reply(char *);
  151. int get_smtp_reply(int);
  152. int send_smtp(int, char *);
  153. int smtp_connect(char *);
  154. int send_email(void);
  155. int scan_file(FILE *);
  156. int send_jung_query(char *, int);
  157. char *get_contact(char *);
  158. /*********************************************************************
  159.  * Prints banner header
  160.  */
  161. void banner(void)
  162. {
  163.     printf("[ CodeBlue v4.2 by Michael (mystic@tenebrous.com) ]\n\n");
  164. }
  165.  
  166.  
  167. /*********************************************************************
  168.  * Prints usage information
  169.  */
  170. void usage(char *prog)
  171. {
  172.     printf("\nUsage: %s [options] <access-log-file>\n"
  173.        "Example: %s /var/www/logs/access_log\n", prog, prog);
  174.     printf("\nTry %s --help for a list of options\n\n", prog);
  175.     exit(1);
  176. }
  177.  
  178. /*********************************************************************
  179.  * Prints help menu
  180.  */
  181. void DieWithHelp(char *prog)
  182. {
  183.     printf("\nUsage: %s [options] <access-log-file>\n"
  184.        "Example: %s /var/www/logs/access_log\n", prog, prog);
  185.     printf("\nOptions can be any of the following:\n"
  186.        "    -e <user@mydomain.com>   Specify the return-to address in each email\n"
  187.        "                              - Default is postmaster@yourhostname\n"
  188.        "    -q                       Send each infected hostname to the Nimda Registry \n "
  189.        "                             at worm.jungnickel.com. This is highly recommended!\n"
  190.        "    -s                       Silent mode - not output goes to stdout\n"
  191.        "--help                       Print this help menu and exit.\n");
  192.     printf("\n");
  193.  
  194.     exit(0);
  195. }
  196.  
  197. /*********************************************************************
  198.  * An option was specified that required an argument - but had non
  199.  */
  200. void DieWithRequire(char *arg)
  201. {
  202.     fprintf(stderr, "[ ERROR: %s requires an argument\n", arg);
  203.     exit(1);
  204. }
  205.  
  206. /*********************************************************************
  207.  * Handles signals we specify later on
  208.  */
  209. void signal_handler(int signo)
  210. {
  211.     time_t tp = time(NULL);
  212.  
  213.     switch (signo) {
  214.     case SIGINT:{
  215.         fprintf(stderr, "\n[***] Caught SIGINT; Cleaning up...\n");
  216.         printf
  217.         ("[***] %d infected hosts were successfully warned, and %d were not.\n",
  218.          hostswarned, hostsnwarned);
  219.         fprintf
  220.         (log,
  221.          "[***] %d infected hosts were successfully warned, and %d were not.\n",
  222.          hostswarned, hostsnwarned);
  223.         fprintf(log, "\n[ LOG END - %s ]\n", chop(ctime(&tp)));
  224.         fclose(log);
  225.         exit(1);
  226.     }
  227.     case SIGPIPE:{
  228.         if(!(flags & FL_BEQUIET))
  229.         fprintf(stderr,
  230.             "[ ERROR: Caught SIGPIPE, skipping this host...\n");
  231.         fprintf(log,
  232.             "[ ERROR: Caught SIGPIPE, skipping this host...\n");
  233.         signal_init();
  234.         Close(mainsock);
  235.         scan_file(fp);
  236.     }
  237.     default:{
  238.         fprintf(stderr,
  239.             "\n[ SIGNAL: %s; Attempting to continue...\n",
  240.             sys_siglist[signo]);
  241.         fprintf(log, "\n..... SIGNAL: %s; Attempting to continue...\n",
  242.             sys_siglist[signo]);
  243.         Close(mainsock);
  244.         signal_init();
  245.         scan_file(fp);
  246.     }
  247.     }
  248. }
  249.  
  250.  
  251. /*
  252.  * siginal_init:
  253.  * sets up all the signals we'd like
  254.  * to handle specially
  255.  */
  256. void signal_init(void)
  257. {
  258.     struct sigaction sa_old, sa_new;
  259.  
  260.     /* signal handling */
  261.     sa_new.sa_handler = signal_handler;
  262.     sigemptyset(&sa_new.sa_mask);
  263.     sa_new.sa_flags = 0;
  264.     sigaction(SIGINT, &sa_new, &sa_old);
  265.     sigaction(SIGPIPE, &sa_new, &sa_old);
  266. }
  267.  
  268.  
  269.  
  270. /*********************************************************************
  271.  * Our close() wrapper
  272.  */
  273. int Close(int sd)
  274. {
  275.     return (close(sd));
  276. }
  277.  
  278. /*********************************************************************
  279.  * This attempts to resolve a hostname, and stores
  280.  * the IP address in a sin structure on success
  281.  */
  282. int resolv(const char *name, struct sockaddr_in *addr)
  283. {
  284.     struct hostent *host;
  285.     memset(addr, 0, sizeof(struct sockaddr_in));
  286.  
  287.     addr->sin_addr.s_addr = inet_addr(name);
  288.  
  289.     if (addr->sin_addr.s_addr == -1) {
  290.     if ((host = gethostbyname(name)) == NULL)
  291.         return -1;
  292.  
  293.     addr->sin_family = host->h_addrtype;
  294.     memcpy((caddr_t) & addr->sin_addr, host->h_addr, host->h_length);
  295.     }
  296.     return 0;
  297. }
  298.  
  299.  
  300. /*********************************************************************
  301.  * Returns str without the trailing \n character
  302.  */
  303. char *chop(char *str)
  304. {
  305.     int i = 0;
  306.     while (str[i]) {
  307.     if (str[i] == '\n')
  308.         str[i] = '\0';
  309.     i++;
  310.     }
  311.     return str;
  312. }
  313.  
  314.  
  315. /*********************************************************************
  316.  * prints invalid SMTP reply
  317.  */
  318. void invalid_reply(char *msg)
  319. {
  320.     fflush(stdout);
  321.     fprintf(stderr, "[ Bad SMTP reply: %s\n", msg);
  322.     fprintf(log, "..... Bad SMTP reply: %s\n", msg);
  323.     return;
  324. }
  325.  
  326. /*********************************************************************
  327.  * fetches a reply from the SMTP server
  328.  */
  329. int get_smtp_reply(int sd)
  330. {
  331.     char response[1024];
  332.     char reply_message[1024];    /* will hold the reply, minus the numeric prefix */
  333.     int i = 0;
  334.     int numeric;
  335.     fd_set rset;
  336.     struct timeval tv;
  337.     int elapsed = 0;
  338.  
  339.     /*
  340.      * We'll loop infinately, receiving
  341.      * 1 byte at a time until we receive a carriage return
  342.      * or line-feed character, signifying the end of the output
  343.      */
  344.     /*
  345.      * set timeout on our socket descriptor
  346.      */
  347.     tv.tv_sec = SMTP_TIMEOUT;
  348.     tv.tv_usec = 0;
  349.     FD_ZERO(&rset);
  350.     FD_SET(sd, &rset);
  351.  
  352.  
  353.     while (TRUE) {
  354.     if (select((sd + 1), &rset, NULL, NULL, &tv) < 0) {
  355.         if (errno != EINPROGRESS) {
  356.         fprintf(stderr, "[ ERROR: select() failed: %s\n",
  357.             strerror(errno));
  358.         return -1;
  359.         }
  360.     }
  361.     if (recv(sd, (int *) &response[i], 1, RECV_FL) < 0) {
  362.         if (errno == EAGAIN) {
  363.         if (elapsed >= SMTP_TIMEOUT) {
  364.             fprintf(stderr, "[ ERROR: operation timed out\n");
  365.             fprintf(log, "..... ERROR: operation timed out\n");
  366.             return -1;
  367.         }
  368.         elapsed++;
  369.         usleep(SMTP_TIMEOUT * 10000);
  370.         continue;
  371.         } else {
  372.         if (!(flags & FL_BEQUIET))
  373.         fprintf(stderr, "[ ERROR: recv() failed: %s\n",
  374.             strerror(errno));
  375.         fprintf(log, "..... ERROR: recv() failed: %s\n",
  376.             strerror(errno));
  377.         return -1;
  378.         }
  379.     }
  380.     if ((response[i] == '\n')
  381.         || ((response[i] == '\n') && (response[i + 1] == '\n')))
  382.         break;
  383.     i++;
  384.     }
  385.  
  386.     /*
  387.      * this will store the numeric portion of the reply
  388.      * into numeric:
  389.      */
  390.     numeric = atoi((strtok(response, " ")));
  391.  
  392.     /*
  393.      * This will copy the reply, without
  394.      * the numeric prefix into reply_message
  395.      */
  396.     for (i = 4; i < (strlen(response) + 1); i++) {
  397.     if ((response[i] == '\0') || (response[i] == '\n')
  398.         || (response[i] == '\r'))
  399.         break;
  400.     reply_message[i - 4] = response[i];
  401.     }
  402.     response[i] = '\0';
  403.  
  404.  
  405.     /*
  406.      * Now let's check the numeric reply
  407.      * replies based on RFC 821 (SMTP)
  408.      */
  409.     switch (numeric) {
  410.     /*
  411.      * These are replies we can handle (Non-error)
  412.      */
  413.     case 220:            /* Service Ready */
  414.     case 221:{
  415.         lastresponse = numeric;
  416.         return 0;
  417.     }            /* Service closing connection */
  418.     case 250:            /* Requested mail action okay, completed */
  419.     case 251:            /* User not local, will forward to <forward-path> */
  420.     case 354:            /* Start mail intput, end with <CRLF>.<CRLF> */
  421.     break;
  422.     default:{
  423.         invalid_reply(reply_message);
  424.         return -1;
  425.     }
  426.     }
  427.     lastresponse = numeric;
  428.     return 0;
  429. }
  430.  
  431. /*********************************************************************
  432.  * sends the SMTP string
  433.  * we're gonna poll the socket.. fyi
  434.  */
  435. int send_smtp(int sd, char *buffer)
  436. {
  437.     if (send(sd, buffer, strlen(buffer), 0) < 0)
  438.     return -1;
  439.     if (lastresponse != 354) {
  440.     if (get_smtp_reply(sd) < 0)
  441.         return -1;
  442.     }
  443.     return SUCCESS;
  444. }
  445.  
  446.  
  447. /*********************************************************************
  448.  * smtp_connect:
  449.  * creates a socket and connects to it,
  450.  * returning the socket file descriptor.
  451.  */
  452. int smtp_connect(char *hostname)
  453. {
  454.     struct sockaddr_in sin;
  455.     fd_set rset;
  456.     struct timeval tv;
  457.     int ttl = 255;
  458.  
  459.     /*
  460.      * This will resolve the hostname, if possible,
  461.      * and store the 32bit address in our sin structure
  462.      */
  463.     if (resolv(hostname, &sin) < 0) {
  464.     fprintf(stderr, "[ ERROR: could not resolve %s\n", hostname);
  465.     fprintf(log, "..... ERROR: could not resolve %s\n", hostname);
  466.     return -1;
  467.     }
  468.  
  469.     sin.sin_family = AF_INET;
  470.     sin.sin_port = htons(SMTP_PORT);
  471.  
  472.     if ((mainsock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  473.     fprintf(stderr, "[ ERROR: socket() failed: %s\n", strerror(errno));
  474.     fprintf(log, "..... ERROR: socket() failed: %s\n",
  475.         strerror(errno));
  476.     return -1;
  477.     }
  478.  
  479.     /*
  480.      * Set socket non-blocking
  481.      */
  482.     fcntl(mainsock, F_SETFL, O_NONBLOCK);
  483.  
  484.     if (connect
  485.     (mainsock, (struct sockaddr *) &sin,
  486.      sizeof(struct sockaddr_in)) < 0) {
  487.     if (errno == EINPROGRESS);    /* do nothing */
  488.     else {
  489.         fprintf(stderr, "[ ERROR: connect() failed: %s\n",
  490.             strerror(errno));
  491.         fprintf(log, "..... ERROR: connect() failed: %s\n",
  492.             strerror(errno));
  493.         Close(mainsock);
  494.         return -1;
  495.     }
  496.     }
  497.  
  498.     /*
  499.      * set timeout on our socket descriptor
  500.      */
  501.     tv.tv_sec = SMTP_TIMEOUT;
  502.     tv.tv_usec = 0;
  503.     FD_ZERO(&rset);
  504.     FD_SET(mainsock, &rset);
  505.  
  506.     while (TRUE) {
  507.     if (select((mainsock + 1), &rset, NULL, NULL, &tv) != 1) {
  508.         if (errno == EINPROGRESS);
  509.         else {
  510.         fprintf(stderr, "[ ERROR: select() failed: %s\n",
  511.             strerror(errno));
  512.         Close(mainsock);
  513.         return -1;
  514.         }
  515.     }
  516.     break;
  517.     }
  518.  
  519.     /*
  520.      * set socket options...
  521.      */
  522.  
  523.     setsockopt(mainsock, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
  524.  
  525.     /*
  526.      * return our socket descriptor
  527.      */
  528.     return mainsock;
  529. }
  530.  
  531.  
  532. /*********************************************************************
  533.  * sends email
  534.  */
  535. int send_email(void)
  536. {
  537.     int sd;
  538.     char buffer[2048];
  539.     char *email;
  540.     char *user = malloc(sizeof(char) * 512);
  541.     char *host = malloc(sizeof(char) * 512);
  542.  
  543.     /* 
  544.      * get technical contact:
  545.      */
  546.     if (flags & FL_WHOIS) {
  547.     if (!(flags & FL_BEQUIET))
  548.     printf("[ Finding technical contact information... ");
  549.     fprintf(log, "..... Finding technical contact information... ");
  550.     if ((email = get_contact(infected_host)) == NULL) {
  551.         printf("not found!\n");
  552.         fprintf(log, "not found!\n");
  553.     }
  554.     if (!(flags & FL_BEQUIET))
  555.     printf("found!\n");
  556.     user = strtok(email, "@");
  557.     user[strlen(user)] = '\0';
  558.     host = strtok(NULL, "@");
  559.     host[strlen(host)] = '\0';
  560.     if (!(flags & FL_BEQUIET))
  561.     printf("[ Emailing %s@%s in regards to %s\n", user, host,
  562.            infected_host);
  563.     fprintf(log, "..... Emailing %s@%s in regards to %s\n", user, host,
  564.         infected_host);
  565.     } else {
  566.     strcpy(user, SMTP_USER);
  567.     strcpy(host, infected_host);
  568.     }
  569.  
  570.  
  571.     if ((sd = smtp_connect(host)) < SUCCESS)
  572.     return -1;
  573.  
  574. /* Step 0 - Get initial server response */
  575.     get_smtp_reply(sd);
  576.  
  577.  
  578. /* Step 1 - Send HELO */
  579.     sprintf(buffer, "HELO localhost\r\n");
  580.     if (send_smtp(sd, buffer) < SUCCESS)
  581.     return -1;
  582.  
  583.  
  584. /* Step 2 - MAIL FROM */
  585.     sprintf(buffer, "MAIL FROM: <%s>\r\n", reply);
  586.     if (send_smtp(sd, buffer) < SUCCESS)
  587.     return -1;
  588.  
  589.  
  590. /* Step 3 - RCPT TO */
  591.     sprintf(buffer, "RCPT TO: <%s>\r\n", user);
  592.     if (send_smtp(sd, buffer) < SUCCESS)
  593.     return -1;
  594.  
  595.  
  596. /* Step 4 - DATA */
  597.     sprintf(buffer, "DATA\r\n");
  598.     if (send_smtp(sd, buffer) < SUCCESS)
  599.     return -1;
  600.  
  601.  
  602. /* Step 5 - To: */
  603.     sprintf(buffer, "To: infected host <%s@%s>\r\n", SMTP_USER,
  604.         infected_host);
  605.     if (send_smtp(sd, buffer) < SUCCESS)
  606.     return -1;
  607.  
  608.  
  609. /* Step 6 - Subject: */
  610.     sprintf(buffer, "Subject: %s\r\n", SMTP_SUBJECT);
  611.     if (send_smtp(sd, buffer) < SUCCESS)
  612.     return -1;
  613.  
  614. /* Step 7 - make High Priority */
  615.     sprintf(buffer, "X-Priority: 1\r\nX-MSMail-Priority: High\r\n");
  616.     if (send_smtp(sd, buffer) < SUCCESS)
  617.     return -1;
  618.  
  619. /* Step 8 - actual msesage */
  620.     sprintf(buffer, message, infected_host, infected_host, logline,
  621.         wormstyle);
  622.     if (send_smtp(sd, buffer) < SUCCESS)
  623.     return -1;
  624.  
  625.  
  626. /* Step 9 - QUIT */
  627.     sprintf(buffer, "QUIT\r\n");
  628.     if (send_smtp(sd, buffer) < SUCCESS)
  629.     return -1;
  630.  
  631.  
  632.     /*
  633.      * Close our socket descriptor and return
  634.      */
  635.     Close(sd);
  636.     free(host);
  637.     free(user);
  638.  
  639.     return SUCCESS;
  640. }
  641.  
  642. /*********************************************************************
  643.  * scans apache access log file for infected CodeRed (1/2) hosts
  644.  */
  645. int scan_file(FILE * fp)
  646. {
  647.     char buffer[1024];
  648.     int i = 0;
  649.     int found_infected = 0;    /* BOOL */
  650.     struct sockaddr_in sin;
  651.  
  652.     fseek(fp, filepos, SEEK_SET);
  653.  
  654.     while (!feof(fp)) {
  655.     i = 0;            /* reset i */
  656.     found_infected = 0;    /* reset found_infected */
  657.     fgets(buffer, 1024, fp);
  658.     filepos = ftell(fp);
  659.  
  660.  
  661.     for (; i < MAX_TRIGGERS; i++) {
  662.         if (strstr(buffer, trigger[i]) != NULL) {
  663.         found_infected = 1;    /* we've found an infected host */
  664.         if (flags & FL_SENDQUERY)
  665.             send_jung_query(infected_host, i);
  666.         switch (i) {
  667.         case 0:{
  668.             strcpy(wormstyle, "Code-Red 1");
  669.             break;
  670.             }
  671.         case 1:{
  672.             strcpy(wormstyle, "Code-Red 2");
  673.             break;
  674.             }
  675.         case 2:{
  676.             strcpy(wormstyle, "Nimda");
  677.             break;
  678.             }
  679.  
  680.         default:{
  681.             strcpy(wormstyle, "Unknown");
  682.             break;
  683.             }
  684.         }
  685.         }
  686.     }
  687.  
  688.     if (found_infected == 1) {
  689.  
  690.         strcpy(logline, buffer);
  691.         strcpy(infected_host, strtok(buffer, " "));
  692.  
  693.         if (resolv(infected_host, &sin) < 0) {
  694.     if (!(flags & FL_BEQUIET))
  695.         fprintf(stderr, "[ ERROR: Couldn't resolve %s: %s\n",
  696.             infected_host, strerror(errno));
  697.         } else {
  698.         strcpy(infected_host, inet_ntoa(sin.sin_addr));
  699.         }
  700.  
  701.  
  702.     if (!(flags & FL_BEQUIET))
  703.         printf
  704.         ("\n\n[ (%s) Infected host [%s] - Sending email...\n",
  705.          wormstyle, infected_host);
  706.         fprintf(log,
  707.             "\n\n..... (%s) Infected host [%s] - Sending email...\n",
  708.             wormstyle, infected_host);
  709.  
  710.         if (strstr(hostlist, infected_host) != NULL) {
  711.     if (!(flags & FL_BEQUIET))
  712.         fprintf(stderr, "[ Host already processed\n");
  713.         fprintf(log, "..... Host already processed\n");
  714.         continue;
  715.         }
  716.  
  717.  
  718.         if (send_email() < SUCCESS) {
  719.     if (!(flags & FL_BEQUIET))
  720.         fprintf(stderr,
  721.             "[ A previous error prevented us from emailing %s\n",
  722.             infected_host);
  723.         fprintf(log,
  724.             "..... A previous error prevented us from emailing %s\n",
  725.             infected_host);
  726.         hostsnwarned++;    /* hosts not warned */
  727.         } else {
  728.     if (!(flags & FL_BEQUIET))
  729.         printf("[ Host was successfully warned via email\n");
  730.         fprintf(log,
  731.             "..... Host was successfully warned via email\n");
  732.         hostswarned++;
  733.         strcat(hostlist, infected_host);    /* add host to list */
  734.         }
  735.  
  736.     }
  737.     }
  738.     return 0;
  739. }
  740.  
  741. /*********************************************************************
  742.  * Code to retrieve technical contact email for specified
  743.  * address.. We'll then email that address as well if the user
  744.  * specified -w
  745.  */
  746. char *get_contact(char *domain)
  747. {
  748.     FILE *fp;
  749.     char buffer[1024], path[1024], *email = NULL;
  750.  
  751.  
  752.     /*
  753.      * Mold the path + args for whois
  754.      */
  755.     sprintf(path, "%s %s\n", WHOIS_PATH, domain);
  756.  
  757.     /*
  758.      * Open a pipe to our whois binary:
  759.      */
  760.     if ((fp = popen(path, "r")) == NULL) {
  761.     fprintf(stderr, "[ ERROR: Can't execute %s: %s\n", WHOIS_PATH,
  762.         strerror(errno));
  763.     fprintf(log, "..... ERROR: Can't execute %s: %s\n", WHOIS_PATH,
  764.         strerror(errno));
  765.     return NULL;
  766.     }
  767.  
  768.     /*
  769.      * Go through the output, looking for contact email
  770.      */
  771.     while (!feof(fp)) {
  772.     fgets(buffer, 1024, fp);
  773.  
  774.     /*
  775.      * Search string for U.S. style whois responses:
  776.      */
  777.  
  778.     if ((strstr(buffer, "Technical") != NULL)
  779.         || (strstr(buffer, "Coordinator") != NULL)) {
  780.         fgets(buffer, 1024, fp);
  781.         email = strtok(buffer, " ");
  782.         email = strtok(NULL, " ");
  783.         email = strtok(NULL, " ");
  784.         email = strtok(NULL, " ");
  785.         break;        /* email should hold the proper address now */
  786.     }
  787.     /*
  788.      * Search string for non-U.S. style whois responses:
  789.      */
  790.     if ((strstr(buffer, "Email:") != NULL)
  791.         || (strstr(buffer, "e-mail:") != NULL)) {
  792.         email = strtok(buffer, " ");
  793.         email = strtok(NULL, " ");
  794.         break;        /* email should hold the proper address now */
  795.     }
  796.     }
  797.  
  798.     fclose(fp);
  799.  
  800.     return chop(email);
  801. }
  802.  
  803. /*********************************************************************
  804.  * Queries the web-server at worm.jungnickel.com,
  805.  * adding each infected host to their database..
  806.  */
  807. int send_jung_query(char *host, int type)
  808. {
  809.     struct sockaddr_in sin;
  810.     char wormtype[8];
  811.     char querystring[512];
  812.     char recvbuf[8];
  813.     int sock;
  814.  
  815.     /*
  816.      * Their CGI understands "codered" and "nimda"
  817.      * as of this release 
  818.      */
  819.     switch (type) {
  820.     case 0:
  821.     case 1:{
  822.         strcpy(wormtype, "codered");
  823.         break;
  824.     }
  825.     case 2:{
  826.         strcpy(wormtype, "nimda");
  827.         break;
  828.     }
  829.     }
  830.  
  831.     wormtype[strlen(wormtype)] = '\0';
  832.  
  833.     memset(&sin, 0, sizeof(struct sockaddr_in));
  834.  
  835.  
  836.  
  837.     if (!(flags & FL_BEQUIET))
  838.     printf("\n[ Querying worm.jungnickel.com 'Nimda Registry': ");
  839.     fprintf(log,
  840.         "\n..... Querying worm.jungnickel.com 'Nimda Registry': ");
  841.     if (resolv("worm.jungnickel.com", &sin) < 0) {
  842.     printf(" failed.\n\n");
  843.     return -1;
  844.     }
  845.  
  846.  
  847.     sin.sin_family = AF_INET;
  848.     sin.sin_port = htons(80);    /* HTTP */
  849.  
  850.     if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  851.     if (!(flags & FL_BEQUIET))
  852.     printf(" failed.\n\n");
  853.     return -1;
  854.     }
  855.  
  856.     if (connect(sock, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
  857.     if (!(flags & FL_BEQUIET))
  858.     printf(" failed.\n\n");
  859.     return -1;
  860.     }
  861.  
  862.     sprintf(querystring, "GET ?action=submit&type=%s&ip=%s\r\n", wormtype,
  863.         host);
  864.     if (send(sock, querystring, strlen(querystring), 0) < 0) {
  865.     if (!(flags & FL_BEQUIET))
  866.     printf(" failed.\n\n");
  867.     return -1;
  868.     }
  869.  
  870.     if (recv(sock, recvbuf, 7, 0) < 0) {
  871.     printf(" failed.\n\n");
  872.     return -1;
  873.     }
  874.     recvbuf[strlen(recvbuf)] = '\0';
  875.     if (!(flags & FL_BEQUIET))
  876.     printf("\n[ worm.jungnickel.com says: %s\n", chop(recvbuf));
  877.     fprintf(log, "\n..... worm.jungnickel.com says: %s\n", chop(recvbuf));
  878.  
  879.     Close(sock);
  880.     return 0;
  881. }
  882.  
  883. /*********************************************************************
  884.  * Hmm. I wonder what main() does...
  885.  */
  886. int main(int argc, char **argv)
  887. {
  888.     char logfile[1024];
  889.     char accesslog[1024];
  890.     char timebuf[256];
  891.     char hostname[256];
  892.     time_t tp, start, finish, total;
  893.     struct tm *tms;
  894.     /*uid_t userid;*/
  895.  
  896.  
  897.     /*
  898.      * We'll first check the userid.. 
  899.      * CodeBlue must be run as root for security reasons.
  900.      */
  901. /*
  902.     if ((userid = getuid()) != 0) {
  903.     fprintf(stderr, "uid %d is invalid!\n", userid);
  904.     fprintf(stderr, "This program MUST be run as root\n");
  905.     exit(1);
  906.     }
  907. */
  908.     /*
  909.      * Initialize signal handling
  910.      */
  911.     signal_init();
  912.  
  913.  
  914.     /* 
  915.      * let's make stdout, stderr, and log unbuffered..
  916.      */
  917.     setvbuf(stdout, NULL, _IONBF, 0);
  918.     setvbuf(stderr, NULL, _IONBF, 0);
  919.  
  920.     /* 
  921.      * Display banner
  922.      */
  923.     banner();
  924.  
  925.  
  926.     /*
  927.      * Make sure we have at least 3 arguments
  928.      */
  929.     if ((argv[1]) && (strcmp(argv[1], "--help") == 0))
  930.     DieWithHelp(argv[0]);
  931.     if (argc < 2)
  932.     usage(argv[0]);
  933.  
  934.     /* 
  935.      * We'll set the reply-to address to a default value
  936.      * based on hostname:
  937.      */
  938.  
  939.     gethostname(hostname, 256);
  940.     strcat(reply, "postmaster@");
  941.     strcat(reply, hostname);
  942.  
  943.   /******************************************************/
  944.  
  945.     /* 
  946.      * Parse command line, storing flags in the 'flags' global variable
  947.      */
  948.     if (argc > 2) {
  949.     int i = 0;
  950.     while (i < argc) {
  951.         if (strcmp(argv[i], "--help") == 0)
  952.         DieWithHelp(argv[0]);    /* --help */
  953.         if (argv[i][0] == '-')
  954.         switch (argv[i][1]) {
  955.         case 'e':{    /* return email address */
  956.             if ((!argv[i + 1]) || (argv[i + 1][0] == '-'))
  957.                 DieWithRequire(argv[i]);
  958.             strcpy(reply, argv[i + 1]);
  959.             break;
  960.             }
  961.         case 'p':{    /* path to whois binary */
  962.             if ((!argv[i + 1]) || (argv[i + 1][0] == '-'))
  963.                 DieWithRequire(argv[i]);
  964.             strcpy(whoispath, argv[i + 1]);
  965.             break;
  966.             }
  967.         case 'q':{    /* send query to Nimda Registry */
  968.             flags |= FL_SENDQUERY;
  969.             break;
  970.             }
  971.         case 'w':{    /* whois lookup technical contact */
  972.             flags |= FL_WHOIS;
  973.             break;
  974.             }
  975.                 case 's':{  /* silent mode */
  976.                         flags |= FL_BEQUIET;
  977.                         break;
  978.                 }
  979.         default:{    /* dunno */
  980.             fprintf(stderr,
  981.                 "[ ERROR: Unrecognized option: %s\n",
  982.                 argv[i]);
  983.             break;
  984.             }
  985.         }
  986.         i++;
  987.     }
  988.     }
  989.     strcpy(accesslog, argv[argc - 1]);
  990.  
  991.  
  992.  
  993.     /* 
  994.      * Validate email address:
  995.      */
  996.     if (reply) {
  997.     int i = 0;
  998.     int tally = 0;
  999.     while (reply[i]) {
  1000.         if ((reply[i] == '@') || (reply[i] == '.'))
  1001.         tally++;
  1002.         i++;
  1003.     }
  1004.     if (tally < 2) {
  1005.         fprintf(stderr,
  1006.             "[ ERROR: %s does not appear to be valid email address\n",
  1007.             reply);
  1008.         return -1;
  1009.     }
  1010.     }
  1011.  
  1012.     /* 
  1013.      * local fp will point to the specified access log
  1014.      * Let's open that now and scan it..
  1015.      */
  1016.     if ((fp = fopen(accesslog, "r")) == NULL) {
  1017.     fprintf(stderr, "[ ERROR: Couldn't open %s for reading: %s\n",
  1018.         accesslog, strerror(errno));
  1019.     return FAILURE;
  1020.     }
  1021.  
  1022.     /*
  1023.      * Let's build the name for our logfile, based on date.
  1024.      * It will be opened for append.
  1025.      */
  1026.     tp = time(NULL);
  1027.     tms = localtime(&tp);
  1028.     strftime(timebuf, 128, "%b-%d-%G", tms);
  1029.     sprintf(logfile, "codeblue-scan-%s.log", timebuf);
  1030.  
  1031.     /*
  1032.      * the global FILE stream log will be opened for append
  1033.      */
  1034.     if ((log = fopen(logfile, "a")) == NULL) {
  1035.     fprintf(stderr, "[ ERROR: Couldn't open %s for append: %s\n",
  1036.         logfile, strerror(errno));
  1037.     return FAILURE;
  1038.     }
  1039.  
  1040.     setvbuf(log, NULL, _IONBF, 0);
  1041.  
  1042.     tp = time(NULL);
  1043.     fprintf(log, "[ LOG START - %s ]\n", chop(ctime(&tp)));
  1044.  
  1045.  
  1046.  
  1047.  
  1048.     start = time(NULL);        /* set start time */
  1049.  
  1050.     printf("[ Scanning %s for infected hosts\n", accesslog);
  1051.     if (scan_file(fp) < SUCCESS)
  1052.     return FAILURE;
  1053.  
  1054.     finish = time(NULL);    /* finish time */
  1055.  
  1056.     total = (finish - start);    /* total time elapsed */
  1057.  
  1058.     printf("\n[***] Task completed in %d minutes, %d seconds!\n",
  1059.        (int) (total / 60), (int) (total % 60));
  1060.     printf
  1061.     ("[***] %d infected hosts were were successfully warned, and %d were not\n",
  1062.      hostswarned, hostsnwarned);
  1063.  
  1064.  
  1065.     tp = time(NULL);
  1066.     fprintf(log, "[ LOG END - %s ]\n", chop(ctime(&tp)));
  1067.  
  1068.  
  1069.     fclose(fp);
  1070.     fclose(log);
  1071.  
  1072.  
  1073.     return SUCCESS;
  1074. }
  1075.  
  1076. /*
  1077.  * Please do not alter these. Thank you for your respect.
  1078.  */
  1079. static const char rcsid[] =
  1080.     { "$Creator: Michael Behan (mystic@tenebrous.com $" };
  1081. static const char rcsid2[] =
  1082.     { "$Copyright: (c) 2001 mystic@tenebrous.com $" };
  1083.